package client;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;

import java.util.List;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import be.ipl.jack.domaine.De;
import be.ipl.jack.domaine.Partie;
import be.ipl.jack.usecases.GestionPartie;


public class TestNG_21 {
	private static GestionPartie gp;
	
	private String joueur1 = "Michel";
	private String joueur2 = "Emmeline";
	private String joueur3 = "Olivier";
	
	@BeforeClass
	public static void setUpBeforeClass() {
		try {
			Context jndi = new InitialContext();
			gp = (GestionPartie) jndi.lookup("ejb:21EAR/21EJB/GestionPartieImpl!be.ipl.jack.usecases.GestionPartie");
			//gp = (GestionPartie) jndi.lookup("ejb:/21EJB/GestionPartieImpl!be.ipl.jack.usecases.GestionPartie");
			
		} catch (NamingException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void testRejoindrePartie() {
		assertTrue(gp.rejoindreLaPartie(joueur1));
		assertTrue(gp.rejoindreLaPartie(joueur2));
		assertTrue(gp.rejoindreLaPartie(joueur3));
		assertFalse(gp.rejoindreLaPartie(joueur1));
	}
	
	@Test(dependsOnMethods="testRejoindrePartie")
	public void testCommencerpartie() {
		assertTrue(gp.commencerPartie());
		assertFalse(gp.commencerPartie());
		assertEquals("Emmeline", gp.joueurCourant());
	}
	
	@Test(dependsOnMethods="testCommencerpartie")
	public void testLancerDes1() {
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		List<De> des = gp.listerDesJoues();
		assertEquals(3, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(points, gp.mesPoints());
		System.out.println(gp.joueurCourant() + " lancer 1 : score obtenu : " + points);
	}
	
	@Test(dependsOnMethods="testLancerDes1")
	public void testEcarteDe1() {
		assertTrue(gp.ecarterDe(3));
		assertFalse(gp.ecarterDe(3));
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
	}
	
	@Test(dependsOnMethods="testEcarteDe1")
	public void testLancerDes2() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 2 : score obtenu : " + score);
	}

	@Test(dependsOnMethods="testLancerDes2") 
	public void testEcarteDe2() {
		int score = gp.mesPoints();
		boolean res = gp.ecarterDe(2);
		if (score >= Partie.VINGT_ET_UN) {
			assertFalse(res);
			return;
		}
		assertTrue(res);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
	}

	@Test(dependsOnMethods="testEcarteDe2")
	public void testLancerDes3() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		if (score >= Partie.VINGT_ET_UN) {
			assertEquals(-1, points);
			return;
		}
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 3 : score obtenu : " + score);
	}
	
	@Test(dependsOnMethods="testLancerDes3")
	public void testAuSuivant() {
		assertTrue(gp.auSuivant());
		assertEquals("Michel", gp.joueurCourant());
	}
	
	@Test(dependsOnMethods="testAuSuivant")
	public void testLancerDes1_j2() {
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		List<De> des = gp.listerDesJoues();
		assertEquals(3, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(points, gp.mesPoints());
		System.out.println(gp.joueurCourant() + " lancer 1 : score obtenu : " + points);
	}
	
	@Test(dependsOnMethods="testLancerDes1_j2") 
	public void testEcarteDe1_j2() {
		assertTrue(gp.ecarterDe(3));
		assertFalse(gp.ecarterDe(3));
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
	}
	
	@Test(dependsOnMethods="testEcarteDe1_j2")
	public void testLancerDes2_j2() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 2 : score obtenu : " + score);
	}

	@Test(dependsOnMethods="testLancerDes2_j2") 
	public void testEcarteDe2_j2() {
		int score = gp.mesPoints();
		boolean res = gp.ecarterDe(2);
		if (score >= Partie.VINGT_ET_UN) {
			assertFalse(res);
			return;
		}
		assertTrue(res);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
	}

	@Test(dependsOnMethods="testEcarteDe2_j2")
	public void testLancerDes3_j2() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		if (score >= Partie.VINGT_ET_UN) {
			assertEquals(-1, points);
			return;
		}
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 3 : score obtenu : " + score);
	}

	@Test(dependsOnMethods="testLancerDes3_j2")
	public void testAuSuivant2() {
		assertTrue(gp.auSuivant());
		assertEquals("Olivier", gp.joueurCourant());
	}
	
	@Test(dependsOnMethods="testAuSuivant2")
	public void testLancerDes1_j3() {
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		List<De> des = gp.listerDesJoues();
		assertEquals(3, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(points, gp.mesPoints());
		System.out.println(gp.joueurCourant() + " lancer 1 : score obtenu : " + points);
	}
	
	@Test(dependsOnMethods="testLancerDes1_j3")
	public void testEcarteDe1_j3() {
		assertTrue(gp.ecarterDe(3));
		assertFalse(gp.ecarterDe(3));
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
	}
	
	@Test(dependsOnMethods="testEcarteDe1_j3")
	public void testLancerDes2_j3() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(2, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 2 : score obtenu : " + score);
	}

	@Test(dependsOnMethods="testLancerDes2_j3") 
	public void testEcarteDe2_j3() {
		int score = gp.mesPoints();
		boolean res = gp.ecarterDe(2);
		if (score >= Partie.VINGT_ET_UN) {
			assertFalse(res);
			return;
		}
		assertTrue(res);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
	}

	@Test(dependsOnMethods="testEcarteDe2_j3")
	public void testLancerDes3_j3() {
		int score = gp.mesPoints();
		int points = gp.lancerLesDes();
		if (score >= Partie.VINGT_ET_UN) {
			assertEquals(-1, points);
			return;
		}
		assertFalse(points == 0);
		assertFalse(points == -1);
		List<De> des = gp.listerDesJoues();
		assertEquals(1, des.size());
		int total = 0;
		for (De de : des)
			total += de.getValeur();
		assertEquals(points, total);
		assertEquals(score + points, gp.mesPoints());
		score += points;
		System.out.println(gp.joueurCourant() + " lancer 3 : score obtenu : " + score);
	}
	
	@Test(dependsOnMethods="testLancerDes3_j3")
	public void testAuSuivant3() {
		assertFalse(gp.auSuivant());
		assertEquals(null, gp.joueurCourant());
	}

	@Test(dependsOnMethods="testAuSuivant3")
	public void testVainqueur() {
		String v = gp.vainqueur();
		if (v == null)
			System.out.println("Il n'y a pas de vainqueur");
		else
			System.out.println("Le vainqueur est " + v);
		assertTrue(gp.estFinie());
	}
}
